<template>
  <view class="waterfall">
    <view id="left-column" class="column"><slot name="left" :leftList="leftList" :parentParams="parentParams"></slot></view>
    <view id="right-column" class="column"><slot name="right" :rightList="rightList" :parentParams="parentParams"></slot></view>
  </view>
</template>

<script>
  /**
   * waterfall 瀑布流
   * @property {Array} flow-list 用于渲染的数据
   * @property {String Number} add-time 单条数据添加到队列的时间间隔，单位ms，
   * @example <waterfall v-model="flowList"></waterfall>
   */
  export default {
    name: 'Waterfall',
    props: {
      value: {
        // 瀑布流数据
        type: Array,
        required: true,
        default() {
          return [];
        },
      },
      // 每次向结构插入数据的时间间隔，间隔越长，越能保证两列高度相近，但是对用户体验越不好
      // 单位ms
      addTime: {
        type: [Number, String],
        default: 200,
      },
      // id值，用于清除某一条数据时，根据此idKey名称找到并移除，如数据为{idx: 22, name: 'lisa'}
      // 那么该把idKey设置为idx
      idKey: {
        type: String,
        default: 'id',
      },
      parentParams: {
        type: Object,
        default: () => {},
      },
    },
    data() {
      return {
        leftList: [],
        rightList: [],
        tempList: [],
        children: [],
      };
    },
    computed: {
      // 破坏flowList变量的引用，否则watch的结果新旧值是一样的
      copyFlowList() {
        return this.cloneData(this.value);
      },
    },
    watch: {
      copyFlowList(nVal, oVal) {
        // 取差值，即这一次数组变化新增的部分
        const startIndex = Array.isArray(oVal) && oVal.length > 0 ? oVal.length : 0;
        // 拼接上原有数据
        this.tempList = this.tempList.concat(this.cloneData(nVal.slice(startIndex)));
        this.splitData();
      },
    },
    mounted() {
      this.tempList = this.cloneData(this.copyFlowList);
      this.splitData();
    },
    methods: {
      getRect(selector, all) {
        return new Promise((resolve) => {
          uni
            .createSelectorQuery()
            .in(this)
            [all ? 'selectAll' : 'select'](selector)
            .boundingClientRect((rect) => {
              if (all && Array.isArray(rect) && rect.length) {
                resolve(rect);
              }
              if (!all && rect) {
                resolve(rect);
              }
            })
            .exec();
        });
      },
      async splitData() {
        if (!this.tempList.length) return;
        const leftRect = await this.getRect('#left-column');
        const rightRect = await this.getRect('#right-column');
        // 如果左边小于或等于右边，就添加到左边，否则添加到右边
        const item = this.tempList[0];
        // 解决多次快速上拉后，可能数据会乱的问题，因为经过上面的两个await节点查询阻塞一定时间，加上后面的定时器干扰
        // 数组可能变成[]，导致此item值可能为undefined
        if (!item) return;
        if (leftRect.height < rightRect.height) {
          this.leftList.push(item);
        } else if (leftRect.height > rightRect.height) {
          this.rightList.push(item);
        } else {
          // 这里是为了保证第一和第二张添加时，左右都能有内容
          // 因为添加第一张，实际队列的高度可能还是0，这时需要根据队列元素长度判断下一个该放哪边
          if (this.leftList.length <= this.rightList.length) {
            this.leftList.push(item);
          } else {
            this.rightList.push(item);
          }
        }
        // 移除临时列表的第一项
        this.tempList.splice(0, 1);
        // 如果临时数组还有数据，继续循环
        if (this.tempList.length) {
          setTimeout(() => {
            this.splitData();
          }, this.addTime);
        }
      },
      // 复制而不是引用对象和数组
      cloneData(data) {
        return JSON.parse(JSON.stringify(data));
      },
      // 清空数据列表
      clear() {
        this.leftList = [];
        this.rightList = [];
        // 同时清除父组件列表中的数据
        this.$emit('input', []);
        this.tempList = [];
      },
      // 清除某一条指定的数据，根据id实现
      remove(id) {
        // 如果findIndex找不到合适的条件，就会返回-1
        let index = -1;
        index = this.leftList.findIndex((val) => val[this.idKey] == id);
        if (index != -1) {
          // 如果index不等于-1，说明已经找到了要找的id，根据index索引删除这一条数据
          this.leftList.splice(index, 1);
        } else {
          // 同理于上方面的方法
          index = this.rightList.findIndex((val) => val[this.idKey] == id);
          if (index != -1) this.rightList.splice(index, 1);
        }
        // 同时清除父组件的数据中的对应id的条目
        index = this.value.findIndex((val) => val[this.idKey] == id);
        if (index != -1) this.$emit('input', this.value.splice(index, 1));
      },
      // 修改某条数据的某个属性
      modify(id, key, value) {
        // 如果findIndex找不到合适的条件，就会返回-1
        let index = -1;
        index = this.leftList.findIndex((val) => val[this.idKey] == id);
        if (index != -1) {
          // 如果index不等于-1，说明已经找到了要找的id，修改对应key的值
          this.leftList[index][key] = value;
        } else {
          // 同理于上方面的方法
          index = this.rightList.findIndex((val) => val[this.idKey] == id);
          if (index != -1) this.rightList[index][key] = value;
        }
        // 修改父组件的数据中的对应id的条目
        index = this.value.findIndex((val) => val[this.idKey] == id);
        if (index != -1) {
          // 首先复制一份value的数据
          const data = this.cloneData(this.value);
          // 修改对应索引的key属性的值为value
          data[index][key] = value;
          this.$emit('input', data);
        }
      },
    },
  };
</script>

<style lang="less" scoped>
  .waterfall {
    display: flex;
    flex-direction: row;
    align-items: flex-start;
  }

  .column {
    // width: 50%;
    display: flex;
    flex: 1;
    flex-direction: column;
    flex-grow: 1;
    flex-shrink: 0;
    height: auto;
    overflow: hidden;
  }

  .image {
    width: 100%;
  }
</style>
